package com.example.hand.doamin.entity;


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Lab1：JDK8 Stream的使用，包括以下API
 *
 * filter：
 * map：
 * mapToInt：
 * mapToLong：
 * mapToDouble：
 * flatMap：
 * distinct：
 * sorted：
 * limit：
 * skip：
 * forEach:打印每个元素
 * collect:是 Java 8 中 Stream 流的一个终止方法，用于将 Stream 流中的元素收集到某个数据结构中，比如 List、Set、Map 等。
 * min:
 * max:
 * count:
 * anyMatch:
 * allMatch:
 * noneMatch:
 * findFirst:
 * findAny:
 * of:
 *
 */
public class Lab1 {
    public static void main(String[] args) {

        /**
         * filter---筛选
         */
        //:Demo1：筛选出Integer集合中大于7的元素，并打印出来
        List<Integer> list = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
        //将List转化为Stream
        Stream<Integer> stream = list.stream();
        stream.filter(i -> i > 7).forEach(System.out::println);

        //Demo2：筛选员工中工资高于8000的人，并形成新的集合。
        ArrayList<Integer> salary = new ArrayList<>();
        salary.add(8900);
        salary.add(7000);
        salary.add(7800);
        salary.add(8200);
        salary.add(9500);
        salary.add(7900);

        System.out.println(salary.stream().filter(integer -> integer > 8000).collect(Collectors.toList()));

        //Demo3：过滤掉不包含"张"的字符串
        //startsWith： 一般用于检测某请求字符串是否以指定的前缀开始的
        List<String> list1 = new ArrayList<>();
        list1.add("张三");
        list1.add("张四");
        list1.add("张五");
        list1.add("赵三");
        list1.add("赵四");
        list1.add("赵五");
        Stream<String> stream1 = list1.stream();
        stream1.filter(i -> i.startsWith("张"));


        //map
        //Demo1：英文字符串数组的元素全部改为大写。
        String[] strArr = {"hello", "word", "java"};
        //将字符串数组转换为Stream对象
        List<String> strList = Arrays.stream(strArr)
                //将每个字符串转换为大写字母
                .map(String::toUpperCase)
                //将转换后的结果收集到一个新的字符串列表中
                .collect(Collectors.toList());
        System.out.println("每个元素大写：" + strList);

        //整数数组每个元素+3
        List<Integer> integers = Arrays.asList(1, 3, 5, 7, 9, 11);
        List<Integer> collect = integers.stream().map(x -> x + 3).collect(Collectors.toList());
        System.out.println("每个元素+3：" + collect);


        //mapToInt  
        //Demo：将一个Stream对象中的元素转换成一个IntStream对象。
        ArrayList<String> lists = new ArrayList<>();
        lists.add("10");
        lists.add("20");
        lists.add("30");
        lists.add("40");
        lists.add("50");

        lists.stream().mapToInt(Integer::parseInt).forEach(System.out::println);


        //mapToDouble
        //Demo：求最大最小值、求和、求平均值
        List<Double> doubles = Arrays.asList(1.0, 2.0, 3.0, 4.0, 2.0);
        double average = doubles.stream().mapToDouble(Number::doubleValue).average().getAsDouble();
        double sum = doubles.stream().mapToDouble(Number::doubleValue).sum();
        double max = doubles.stream().mapToDouble(Number::doubleValue).max().getAsDouble();
        System.out.println("平均值：" + average + "，总和：" + sum + "，最大值：" + max);


        //flatMap
        //Demo：给定单词列表 ["Hello","World"]，返回列表 ["H","e","l","o","W","r","d"]
        // 创建一个包含两个字符串的列表
        List<String> words = Arrays.asList("Hello", "World");

        // 将列表中的每个字符串拆分成单个字符，并将所有字符合并到一个新的列表中
        List<String> letters = words.stream()
                .flatMap(word -> Arrays.stream(word.split("")))
                .collect(Collectors.toList());

        // 打印新列表
        System.out.println(letters);


        /**
         * distinct--->去重
         */
        // 创建一个字符串列表
        List<String> listDistinct = Arrays.asList("apple", "banana", "orange", "apple", "banana");
        // 使用流操作对列表进行去重，并转换为List类型
        List<String> distinctList = listDistinct.stream().distinct().collect(Collectors.toList());
        // 输出去重后的列表
        System.out.println(distinctList);


        /**
         * sorted--->排序
         */
        //Demo:
        List<Integer> integerList = Arrays.asList(1, 23, 4, 54, 623, 2, 6, 345, 23, 8, 56, 435, 234, 234, 234, 4);
        //升序
        System.out.println(integerList.stream().sorted().collect(Collectors.toList()));
        //降序
        //Collections.reverseOrder()
        System.out.println(integerList.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList()));

        /**
         * concat:合并两个流
         * distinct：去重
         * limit：限制从流中获得前n个数据
         * skip：跳过前n个数据
         *
         */
        String[] arr1 = { "a", "b", "c", "d" };
        String[] arr2 = { "d", "e", "f", "g" };

        Stream<String> stream01 = Stream.of(arr1);
        Stream<String> stream02 = Stream.of(arr2);
        // concat:合并两个流     distinct：去重
        List<String> newList = Stream.concat(stream01, stream02).distinct().collect(Collectors.toList());
        // limit：限制从流中获得前n个数据
        List<Integer> collect1 = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
        // skip：跳过前n个数据
        List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());

        System.out.println("流合并：" + newList);
        System.out.println("limit：" + collect);
        System.out.println("skip：" + collect2);


        /**
         * forEach:打印每个元素
         * collect：是 Java 8 中 Stream 流的一个终止方法，用于将 Stream 流中的元素收集到某个数据结构中，比如 List、Set、Map 等。
         */
        List<Integer> forEachlist = Arrays.asList(1, 2, 3, 4, 5);
        forEachlist.forEach(System.out::println);

        List<String> collectlist = Arrays.asList("apple", "banana", "orange");
        System.out.println(collectlist.stream().filter(s -> s.startsWith("a")).collect(Collectors.toList()));

    }
}
